package com.longge.wechat.utils;
 
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

//需要将myeclipse自带的JRE，换成自己的JRE才可以导入以下包
//import sun.misc.BASE64Decoder; 
//import sun.misc.BASE64Encoder;

public class EncrptUtils { 
 /** 
 * 创建密匙 
 *  
 * @param algorithm 
 *            加密算法,可用 DES,DESede,Blowfish 
* @return SecretKey 秘密（对称）密钥 
 */  
public static SecretKey createSecretKey(String algorithm) {  
    // 声明KeyGenerator对象  
    KeyGenerator keygen;  
   // 声明 密钥对象  
    SecretKey deskey = null;  
   try {  
        // 返回生成指定算法的秘密密钥的 KeyGenerator 对象  
        keygen = KeyGenerator.getInstance(algorithm);  
      // 生成一个密钥  
        deskey = keygen.generateKey();  
   } catch (NoSuchAlgorithmException e) {  
        e.printStackTrace();  
    }  
    // 返回密匙  
   return deskey;  
}  

/** 
     * 根据密匙进行DES加密 
     *  
     * @param key 
     *            密匙 
    * @param info 
     *            要加密的信息 
     * @return String 加密后的信息 
     */  
  public static String encryptToDES(SecretKey key, String info) {  
       // 定义 加密算法,可用 DES,DESede,Blowfish  
       String Algorithm = "DES";  
        // 加密随机数生成器 (RNG),(可以不写)  
        SecureRandom sr = new SecureRandom();  
        // 定义要生成的密文  
        byte[] cipherByte = null;  
       try {  
          // 得到加密/解密器  
            Cipher c1 = Cipher.getInstance(Algorithm);  
          // 用指定的密钥和模式初始化Cipher对象  
            // 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)  
            c1.init(Cipher.ENCRYPT_MODE, key, sr);  
          // 对要加密的内容进行编码处理,  
           cipherByte = c1.doFinal(info.getBytes());  
        } catch (Exception e) {  
          e.printStackTrace();  
      }  
      // 返回密文的十六进制形式  
        return byte2hex(cipherByte);  
    }  
    /** 
    * 根据密匙进行DES解密 
     *  
    * @param key 
   *            密匙 
     * @param sInfo 
     *            要解密的密文 
     * @return String 返回解密后信息 
    */  
  public static String decryptByDES(SecretKey key, String sInfo) {  
        // 定义 加密算法,  
        String Algorithm = "DES";  
        // 加密随机数生成器 (RNG)  
        SecureRandom sr = new SecureRandom();  
        byte[] cipherByte = null;  
        try {  
            // 得到加密/解密器  
            Cipher c1 = Cipher.getInstance(Algorithm);  
            // 用指定的密钥和模式初始化Cipher对象  
            c1.init(Cipher.DECRYPT_MODE, key, sr);  
            // 对要解密的内容进行编码处理  
            cipherByte = c1.doFinal(hex2byte(sInfo));  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        // return byte2hex(cipherByte);  
        return new String(cipherByte);  
    }  
  /** 
  * 将二进制转化为16进制字符串 
  *  
   * @param b 
  *            二进制字节数组 
   * @return String 
  */  
  public static String byte2hex(byte[] b) {  
      String hs = "";  
      String stmp = "";  
      for (int n = 0; n < b.length; n++) {  
          stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));  
          if (stmp.length() == 1) {  
              hs = hs + "0" + stmp;  
          } else {  
              hs = hs + stmp;  
          }  
      }  
      return hs.toUpperCase();  
  }  
      /** 
       * 十六进制字符串转化为2进制 
       *  
       * @param hex 
       * @return 
       */  
      public static byte[] hex2byte(String hex) {  
          byte[] ret = new byte[8];  
          byte[] tmp = hex.getBytes();  
          for (int i = 0; i < 8; i++) {  
              ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);  
          }  
          return ret;  
      }   
     public static byte uniteBytes(byte src0, byte src1) {  
	          byte _b0 = Byte.decode("0x" + new String(new byte[] { src0 }))  
	                  .byteValue();  
	          _b0 = (byte) (_b0 << 4);  
	          byte _b1 = Byte.decode("0x" + new String(new byte[] { src1 }))  
	                  .byteValue();  
	          byte ret = (byte) (_b0 ^ _b1);  
	          return ret;  
	     }  
         /** 
           * 进行MD5加密 
         *  
          * @param info 
          *            要加密的信息 
          * @return String 加密后的字符串 
          */  
         public static String encryptToMD5(String info) {  
             byte[] digesta = null;  
             try {  
                 // 得到一个md5的消息摘要  
                 MessageDigest alga = MessageDigest.getInstance("MD5");  
                 // 添加要进行计算摘要的信息  
                 alga.update(info.getBytes());  
                 // 得到该摘要  
                 digesta = alga.digest();  
             } catch (NoSuchAlgorithmException e) {  
                 e.printStackTrace();  
             }  
            // 将摘要转为字符串  
             String rs = byte2hex(digesta);  
             return rs;  
         }  
            /** 
            * 进行SHA加密 
              *  
              * @param info 
             *            要加密的信息 
             * @return String 加密后的字符串 
              */  
             public static String encryptToSHA(String info) {  
                 byte[] digesta = null;  
                 try {  
                     // 得到一个SHA-1的消息摘要  
                     MessageDigest alga = MessageDigest.getInstance("SHA-1");  
                     // 添加要进行计算摘要的信息  
                     alga.update(info.getBytes());  
                    // 得到该摘要  
                     digesta = alga.digest();  
                 } catch (NoSuchAlgorithmException e) {  
                     e.printStackTrace();  
                 }  
                 // 将摘要转为字符串  
                 String rs = byte2hex(digesta);  
                 return rs;  
             }  

//	static Key key;
//	/**
//	 *  将原文加密为密文方法    
//	 * @param srcStr
//	 */ 
//	public static void EncrptUtils(String srcStr){    
//	setKey(srcStr);   //生成密匙   
//}
//	/**
//	 * 根据参数生成KEY   
//	 * @param strKey
//	 */
//	public static void setKey(String strKey){
//		try {
//			KeyGenerator _generator=KeyGenerator.getInstance("DES");
//			_generator.init(new SecureRandom(strKey.getBytes()));
//			key = _generator.generateKey();    
//	        _generator = null;  
//		} catch (NoSuchAlgorithmException e) { 
//			throw new RuntimeException(    
//			           "Error initializing SqlMap class. Cause:" + e); 
//		} 
//	}
//	
//	  /**   
//	   * 加密String明文输入,String密文输出   
//	   */
//	public static String getEncString(String strMing){
//		byte[] byteMi=null;
//		byte[] byteMing=null;
//		String strMi="";
//		BASE64Encoder base64en = new BASE64Encoder();    
//		try {    
//	        byteMing = strMing.getBytes("UTF-8");    
//	        byteMi = getEncCode(byteMing);    
//	        strMi = base64en.encode(byteMi);    
//	      } catch (Exception e) {    
//	        throw new RuntimeException(    
//	        		 "Error initializing SqlMap class. Cause:" + e);     
//	      } finally {    
//	        base64en = null;    
//	        byteMing = null;    
//	        byteMi = null;    
//	      }    
//	      return strMi;  
//	}
//	
//	/**   
//	   * 解密 以String密文输入,String明文输出   
//	   * @param strMi   
//	   * @return   
//	   */   
//	  public static String getDesString(String strMi) {    
//	      BASE64Decoder base64De = new BASE64Decoder();    
//	      byte[] byteMing = null;    
//	      byte[] byteMi = null;    
//	      String strMing ="";    
//	      try {    
//	        byteMi = base64De.decodeBuffer(strMi);    
//	        byteMing = getDesCode(byteMi);    
//	        strMing = new String(byteMing,"UTF-8");    
//	      } catch (Exception e) {    
//	        throw new RuntimeException(    
//	        		 "Error initializing SqlMap class. Cause:" + e);  
//	      } finally {    
//	        base64De = null;    
//	        byteMing = null;    
//	        byteMi = null;    
//	      }    
//	      return strMing;    
//	  }    
//
//	
//	 /**   
//	   * 加密以byte[]明文输入,byte[]密文输出   
//	   * @param byteS   
//	   * @return   
//	   */   
//	  private static byte[] getEncCode(byte[] byteS) {    
//	      byte[] byteFina = null;    
//	      Cipher cipher;    
//	      try {    
//	        cipher = Cipher.getInstance("DES");    
//	        cipher.init(Cipher.ENCRYPT_MODE, key);    
//	        byteFina = cipher.doFinal(byteS);    
//	      } catch (Exception e) {    
//	        throw new RuntimeException(    
//	        		"Error initializing SqlMap class. Cause:" + e);    
//	      } finally {    
//	        cipher = null;    
//	      }    
//	      return byteFina;    
//	  }    
//
//	  /**   
//	   * 解密以byte[]密文输入,以byte[]明文输出   
//	   * @param byteD   
//	   * @return   
//	   */   
//	  private static  byte[] getDesCode(byte[] byteD) {    
//	      Cipher cipher;    
//	      byte[] byteFina = null;    
//	      try {    
//	        cipher = Cipher.getInstance("DES");    
//	        cipher.init(Cipher.DECRYPT_MODE, key);    
//	        byteFina = cipher.doFinal(byteD);    
//	      } catch (Exception e) {    
//	        throw new RuntimeException(    
//	        		"Error initializing SqlMap class. Cause:" + e);  
//	      } finally {    
//	        cipher = null;    
//	      }    
//	      return byteFina;    
//	  }    

             public static void main(String[] args) {
				String s1 = "123";
				String s2 = EncrptUtils.encryptToMD5(s1);
				System.out.println(s2);
			}
}


 
